Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| JavaTM 2 Platform Std. Ed. v1.4.0
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## java.awt
Class Polygon

    java.lang.Object
      |
      +--java.awt.Polygon

All Implemented Interfaces:
  Serializable, Shape

public class Polygon
extends Object
implements Shape, Serializable

The `Polygon` class encapsulates a description of a closed, two-dimensional region within a coordinate space. This region is bounded by an arbitrary number of line segments, each of which is one side of the polygon. Internally, a polygon comprises of a list of (x, y) coordinate pairs, where each pair defines a vertex of the polygon, and two successive pairs are the endpoints of a line that is a side of the polygon. The first and final pairs of (x, y) points are joined by a line segment that closes the polygon. This `Polygon` is defined with an even-odd winding rule. See `WIND_EVEN_ODD` for a definition of the even-odd winding rule. This class's hit-testing methods, which include the `contains`, `intersects` and `inside` methods, use the insideness definition described in the `Shape` class comments.

Since:
  JDK1.0
See Also:
  `Shape`, Serialized Form

Field Summary
`protected Rectangle` | `bounds` Bounds of the polygon.
`int` | `npoints` The total number of points.
`int[]` | `xpoints` The array of x coordinates.
`int[]` | `ypoints` The array of y coordinates.

Constructor Summary
`Polygon()` Creates an empty polygon.
`Polygon(int[] xpoints, int[] ypoints, int npoints)` Constructs and initializes a `Polygon` from the specified parameters.

Method Summary
`void` | `addPoint(int x, int y)` Appends the specified coordinates to this `Polygon`.
`boolean` | `contains(double x, double y)` Determines if the specified coordinates are inside this `Polygon`.
`boolean` | `contains(double x, double y, double w, double h)` Tests if the interior of this `Polygon` entirely contains the specified set of rectangular coordinates.
`boolean` | `contains(int x, int y)` Determines whether the specified coordinates are inside this `Polygon`.
`boolean` | `contains(Point p)` Determines whether the specified `Point` is inside this `Polygon`.
`boolean` | `contains(Point2D p)` Tests if a specified `Point2D` is inside the boundary of this `Polygon`.
`boolean` | `contains(Rectangle2D r)` Tests if the interior of this `Polygon` entirely contains the specified `Rectangle2D`.
`Rectangle` | `getBoundingBox()` Deprecated. As of JDK version 1.1, replaced by `getBounds()`.
`Rectangle` | `getBounds()` Gets the bounding box of this `Polygon`.
`Rectangle2D` | `getBounds2D()` Returns the high precision bounding box of the `Shape`.
`PathIterator` | `getPathIterator(AffineTransform at)` Returns an iterator object that iterates along the boundary of this `Polygon` and provides access to the geometry of the outline of this `Polygon`.
`PathIterator` | `getPathIterator(AffineTransform at, double flatness)` Returns an iterator object that iterates along the boundary of the `Shape` and provides access to the geometry of the outline of the `Shape`.
`boolean` | `inside(int x, int y)` Deprecated. As of JDK version 1.1, replaced by `contains(int, int)`.
`boolean` | `intersects(double x, double y, double w, double h)` Tests if the interior of this `Polygon` intersects the interior of a specified set of rectangular coordinates.
`boolean` | `intersects(Rectangle2D r)` Tests if the interior of this `Polygon` intersects the interior of a specified `Rectangle2D`.
`void` | `invalidate()` Invalidates or flushes any internally-cached data that depends on the vertex coordinates of this `Polygon`.
`void` | `reset()` Resets this `Polygon` object to an empty polygon.
`void` | `translate(int deltaX, int deltaY)` Translates the vertices of the `Polygon` by `deltaX` along the x axis and by `deltaY` along the y axis.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### npoints

    public int npoints

  The total number of points. The value of `npoints` represents the number of valid points in this `Polygon` and might be less than the number of elements in `xpoints` or `ypoints`. This value can be NULL.

  See Also:
    `addPoint(int, int)`

### xpoints

    public int[] xpoints

  The array of x coordinates. The number of elements in this array might be more than the number of x coordinates in this `Polygon`. The extra elements allow new points to be added to this `Polygon` without re-creating this array. The value of `npoints` is equal to the number of valid points in this `Polygon`.

  See Also:
    `addPoint(int, int)`

### ypoints

    public int[] ypoints

  The array of y coordinates. The number of elements in this array might be more than the number of y coordinates in this `Polygon`. The extra elements allow new points to be added to this `Polygon` without re-creating this array. The value of `npoints` is equal to the number of valid points in this `Polygon`.

  See Also:
    `addPoint(int, int)`

### bounds

    protected Rectangle bounds

  Bounds of the polygon. This value can be NULL. Please see the javadoc comments getBounds().

  See Also:
    `getBoundingBox()`, `getBounds()`

Constructor Detail

### Polygon

    public Polygon()

  Creates an empty polygon.

### Polygon

    public Polygon(int[] xpoints,
                   int[] ypoints,
                   int npoints)

  Constructs and initializes a `Polygon` from the specified parameters.

Parameters:
  `xpoints` - an array of x coordinates
  `ypoints` - an array of y coordinates
  `npoints` - the total number of points in the `Polygon`
Throws:
  `NegativeArraySizeException` - if the value of `npoints` is negative.
  `IndexOutOfBoundsException` - if `npoints` is greater than the length of `xpoints` or the length of `ypoints`.
  `NullPointerException` - if `xpoints` or `ypoints` is `null`.

Method Detail

### reset

    public void reset()

  Resets this `Polygon` object to an empty polygon. The coordinate arrays and the data in them are left untouched but the number of points is reset to zero to mark the old vertex data as invalid and to start accumulating new vertex data at the beginning. All internally-cached data relating to the old vertices are discarded. Note that since the coordinate arrays from before the reset are reused, creating a new empty `Polygon` might be more memory efficient than resetting the current one if the number of vertices in the new polygon data is significantly smaller than the number of vertices in the data from before the reset.

  Since:
    1.4
See Also:
  `invalidate()`

### invalidate

    public void invalidate()

  Invalidates or flushes any internally-cached data that depends on the vertex coordinates of this `Polygon`. This method should be called after any direct manipulation of the coordinates in the `xpoints` or `ypoints` arrays to avoid inconsistent results from methods such as `getBounds` or `contains` that might cache data from earlier computations relating to the vertex coordinates.

  Since:
    1.4
See Also:
  `getBounds()`

### translate

    public void translate(int deltaX,
                          int deltaY)

  Translates the vertices of the `Polygon` by `deltaX` along the x axis and by `deltaY` along the y axis.

  Parameters:
    `deltaX` - the amount to translate along the x axis
    `deltaY` - the amount to translate along the y axis
  Since:
    JDK1.1

### addPoint

    public void addPoint(int x,
                         int y)

  Appends the specified coordinates to this `Polygon`.

  If an operation that calculates the bounding box of this `Polygon` has already been performed, such as `getBounds` or `contains`, then this method updates the bounding box.

  See Also:
    `getBounds()`, `contains(java.awt.Point)`

### getBounds

    public Rectangle getBounds()

  Gets the bounding box of this `Polygon`. The bounding box is the smallest `Rectangle` whose sides are parallel to the x and y axes of the coordinate space, and can completely contain the `Polygon`.

  Specified by:
    `getBounds` in interface `Shape`
  Returns:
    a `Rectangle` that defines the bounds of this `Polygon`.
  Since:
    JDK1.1
See Also:
  `Shape.getBounds2D()`

### getBoundingBox

    public Rectangle getBoundingBox()

  Deprecated. As of JDK version 1.1, replaced by `getBounds()`.

  Returns the bounds of this `Polygon`.

  Returns:
    the bounds of this `Polygon`.

### contains

    public boolean contains(Point p)

  Determines whether the specified `Point` is inside this `Polygon`.

  Parameters:
    `p` - the specified `Point` to be tested
  Returns:
    `true` if the `Polygon` contains the `Point`; `false` otherwise.
  See Also:
    `contains(double, double)`

### contains

    public boolean contains(int x,
                            int y)

  Determines whether the specified coordinates are inside this `Polygon`.

  Returns:
    `true` if this `Polygon` contains the specified coordinates, (x, y); `false` otherwise.
  Since:
    JDK1.1
See Also:
  `contains(double, double)`

### inside

    public boolean inside(int x,
                          int y)

  Deprecated. As of JDK version 1.1, replaced by `contains(int, int)`.

  Determines whether the specified coordinates are contained in this `Polygon`.

  Returns:
    `true` if this `Polygon` contains the specified coordinates, (x, y); `false` otherwise.
  See Also:
    `contains(double, double)`

### getBounds2D

    public Rectangle2D getBounds2D()

  Returns the high precision bounding box of the `Shape`.

  Specified by:
    `getBounds2D` in interface `Shape`
  Returns:
    a `Rectangle2D` that precisely bounds the `Shape`.
  See Also:
    `Shape.getBounds()`

### contains

    public boolean contains(double x,
                            double y)

  Determines if the specified coordinates are inside this `Polygon`. For the definition of insideness, see the class comments of `Shape`.

  Specified by:
    `contains` in interface `Shape`
  Returns:
    `true` if the `Polygon` contains the specified coordinates; `false` otherwise.

### contains

    public boolean contains(Point2D p)

  Tests if a specified `Point2D` is inside the boundary of this `Polygon`.

  Specified by:
    `contains` in interface `Shape`
  Parameters:
    `p` - a specified `Point2D`
  Returns:
    `true` if this `Polygon` contains the specified `Point2D`; `false` otherwise.
  See Also:
    `contains(double, double)`

### intersects

    public boolean intersects(double x,
                              double y,
                              double w,
                              double h)

  Tests if the interior of this `Polygon` intersects the interior of a specified set of rectangular coordinates.

  Specified by:
    `intersects` in interface `Shape`
  Parameters:
    `w` - the width of the specified rectangular shape
    `h` - the height of the specified rectangular shape
  Returns:
    `true` if the interior of this `Polygon` and the interior of the specified set of rectangular coordinates intersect each other; `false` otherwise.
  See Also:
    `Area`

### intersects

    public boolean intersects(Rectangle2D r)

  Tests if the interior of this `Polygon` intersects the interior of a specified `Rectangle2D`.

  Specified by:
    `intersects` in interface `Shape`
  Parameters:
    `r` - a specified `Rectangle2D`
  Returns:
    `true` if this `Polygon` and the interior of the specified `Rectangle2D` intersect each other; `false` otherwise.
  See Also:
    `Shape.intersects(double, double, double, double)`

### contains

    public boolean contains(double x,
                            double y,
                            double w,
                            double h)

  Tests if the interior of this `Polygon` entirely contains the specified set of rectangular coordinates.

  Specified by:
    `contains` in interface `Shape`
  Parameters:
    `w` - the width of the set of rectangular coordinates
    `h` - the height of the set of rectangular coordinates
  Returns:
    `true` if this `Polygon` entirely contains the specified set of rectangular coordinates; `false` otherwise.
  See Also:
    `Area`, `Shape.intersects(double, double, double, double)`

### contains

    public boolean contains(Rectangle2D r)

  Tests if the interior of this `Polygon` entirely contains the specified `Rectangle2D`.

  Specified by:
    `contains` in interface `Shape`
  Parameters:
    `r` - the specified `Rectangle2D`
  Returns:
    `true` if this `Polygon` entirely contains the specified `Rectangle2D`; `false` otherwise.
  See Also:
    `contains(double, double, double, double)`

### getPathIterator

    public PathIterator getPathIterator(AffineTransform at)

  Returns an iterator object that iterates along the boundary of this `Polygon` and provides access to the geometry of the outline of this `Polygon`. An optional `AffineTransform` can be specified so that the coordinates returned in the iteration are transformed accordingly.

  Specified by:
    `getPathIterator` in interface `Shape`
  Parameters:
    `at` - an optional `AffineTransform` to be applied to the coordinates as they are returned in the iteration, or `null` if untransformed coordinates are desired
  Returns:
    a `PathIterator` object that provides access to the geometry of this `Polygon`.

### getPathIterator

    public PathIterator getPathIterator(AffineTransform at,
                                        double flatness)

  Returns an iterator object that iterates along the boundary of the `Shape` and provides access to the geometry of the outline of the `Shape`. Only SEG_MOVETO, SEG_LINETO, and SEG_CLOSE point types are returned by the iterator. Since polygons are already flat, the `flatness` parameter is ignored. An optional `AffineTransform` can be specified in which case the coordinates returned in the iteration are transformed accordingly.

  Specified by:
    `getPathIterator` in interface `Shape`
  Parameters:
    `at` - an optional `AffineTransform` to be applied to the coordinates as they are returned in the iteration, or `null` if untransformed coordinates are desired
    `flatness` - the maximum amount that the control points for a given curve can vary from colinear before a subdivided curve is replaced by a straight line connecting the endpoints. Since polygons are already flat the `flatness` parameter is ignored.
  Returns:
    a `PathIterator` object that provides access to the `Shape` object's geometry.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| JavaTM 2 Platform Std. Ed. v1.4.0
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Submit a bug or feature
For further API reference and developer documentation, see Java 2 SDK SE Developer Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.

Java, Java 2D, and JDBC are trademarks or registered trademarks of Sun Microsystems, Inc. in the US and other countries.
Copyright 1993-2002 Sun Microsystems, Inc. 901 San Antonio Road
Palo Alto, California, 94303, U.S.A. All Rights Reserved.